home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / aminet / dev / lang / bcpl4amiga.lha / bcpl / cg.bpl < prev    next >
Text File  |  1988-03-24  |  15KB  |  599 lines
  1. //    CGHDR
  2.  
  3.  
  4. GET "LIBHDR"
  5.  
  6. MANIFEST $(   // OCODE OPERATORS
  7. S.TRUE=4; S.FALSE=5
  8. S.RV=8; S.FNAP=10
  9. S.MULT=11; S.DIV=12; S.REM=13; S.PLUS=14; S.MINUS=15
  10. S.QUERY:16; S.NEG=17
  11. S.EQ=20; S.NE=21; S.LS=22; S.GR=23; S.LE=24; S.GE=25
  12. S.NOT=30; S.LSHIFT=31; S.RSHIFT=32; S.LOGAND=33; S.LOGOR=34
  13. S.EQV=35; S.NEQV=36; S.COND=37
  14. S.LP=40; S.LG=41; S.LN=42; S.LSTR=43; S.LL=44
  15. S.LLP=45; S.LLG=46; S.LLL=47
  16.  
  17. S.RTAP=51; S.GOTO=52
  18. S.RETURN=67; S.FINISH=68
  19. S.SWITCHON=70
  20. S.GLOBAL=76
  21. $)
  22.  
  23. MANIFEST $(
  24. S.SP=80; S.SG=81; S.SL=82; S.STIND=83
  25. S.JUMP=85; S.JT=86; S.JF=87
  26. S.LAB=90; S.STACK=91; S.STORE=92; S.RSTACK=93; S.ENTRY=94
  27. S.SAVE=95; S.FNRN=96; S.RTRN=97; S.RES=98; S.RESLAB=99
  28. S.DATALAB=100; S.ITEML=101; S.ITEMN=102; S.ENDPROC=103; S.END=104
  29. S.CHAR=105; ERROR:108; S.DEBUG:109
  30. $)
  31.  
  32.  
  33.  
  34.  
  35. GLOBAL  $(
  36. CH:100; WORDV:102
  37. INTCODE:105; SYSPRINT:106; SYSIN:107
  38. SSP:110; STATE:111; AD.A:113; AD.K:114
  39. OPTION:128
  40. DATAV:152; DATAP:153; DATAT:154
  41. PROGLENGTH:155; LINEP:156; PARAM:157
  42. OP:171  $)
  43.  
  44. GLOBAL $(
  45. READOP:210; RDN:211; RDL:212
  46. $)
  47.  
  48. GLOBAL $(
  49. GENCODE:230
  50. $)
  51.  
  52. GLOBAL $(
  53. FORCE.NIL:240; FORCE.AD:241; FORCE.AC:242; FORCE.ACAD:243
  54. LOAD:244
  55. STOREIN:246
  56. CGSTRING:250; DATA:251; NEXTPARAM:252
  57. $)
  58.  
  59. GLOBAL $(
  60. CODE:260; COMPLAB:261; OPCODE:262; WR:263; WRN:264
  61. WRDATA:265
  62. $)
  63.  
  64. MANIFEST $(
  65. M.N=0; M.I=1; M.P=2; M.IP=3; M.L=4; M.IL=5; M.G=6; M.IG=7
  66. F.L='L'; F.S='S'; F.A='A'; F.J='J'; F.T='T'; F.F='F'; F.K='K'; F.X='X'
  67. F.D='D'; F.C='C'
  68. NIL=0; AD=1; AC=2; ACAD=3
  69. $)
  70.  
  71. .
  72.  
  73. //    CG1
  74.  
  75.  
  76. GET "CGHDR"
  77.  
  78. STATIC $( WP=0; STRSIZE=0  $)
  79.  
  80. LET T(S) = VALOF
  81.       $( FOR I = 0 TO STRSIZE DO UNLESS S!I=WORDV!I RESULTIS FALSE
  82.          RESULTIS TRUE  $)
  83.  
  84. LET READOP() = VALOF
  85.     $(1 LET S = VEC 20
  86.  
  87.         CH := RDCH() REPEATWHILE CH='*N' \/ CH='*S'
  88.         WP := 0
  89.  
  90.         WHILE 'A'<=CH<='Z' DO
  91.            $( WP := WP + 1
  92.               S!WP := CH
  93.               CH := RDCH()  $)
  94.  
  95.         S!0 := WP
  96.         STRSIZE := PACKSTRING(S, WORDV)
  97.  
  98.         SWITCHON S!1 INTO
  99.      $( DEFAULT: IF CH=ENDSTREAMCH RESULTIS S.END
  100.                  RESULTIS ERROR
  101.  
  102.         CASE 'D':
  103.         RESULTIS T("DATALAB") -> S.DATALAB,
  104.                  T("DIV") -> S.DIV,
  105.                  T("DEBUG") -> S.DEBUG, ERROR
  106.  
  107.         CASE 'E':
  108.         RESULTIS T("EQ") -> S.EQ,
  109.                  T("ENTRY") -> S.ENTRY,
  110.                  T("EQV") -> S.EQV,
  111.                  T("ENDPROC") -> S.ENDPROC,
  112.                  T("END") -> S.END, ERROR
  113.  
  114.         CASE 'F':
  115.         RESULTIS T("FNAP") -> S.FNAP,
  116.                  T("FNRN") -> S.FNRN,
  117.                  T("FALSE") -> S.FALSE,
  118.                  T("FINISH") -> S.FINISH, ERROR
  119.  
  120.  
  121.         CASE 'G':
  122.         RESULTIS T("GOTO") -> S.GOTO,
  123.                  T("GE") -> S.GE,
  124.                  T("GR") -> S.GR,
  125.                  T("GLOBAL") -> S.GLOBAL, ERROR
  126.  
  127.         CASE 'I':
  128.         RESULTIS T("ITEMN") -> S.ITEMN,
  129.                  T("ITEML") -> S.ITEML,  ERROR
  130.  
  131.         CASE 'J':
  132.         RESULTIS T("JUMP") -> S.JUMP,
  133.                  T("JF") -> S.JF,
  134.                  T("JT") -> S.JT,  ERROR
  135.  
  136.         CASE 'L':
  137.         IF WP=2 DO
  138.              SWITCHON S!2 INTO
  139.              $( DEFAULT: RESULTIS ERROR
  140.                 CASE 'E': RESULTIS S.LE
  141.                 CASE 'N': RESULTIS S.LN
  142.                 CASE 'G': RESULTIS S.LG
  143.                 CASE 'P': RESULTIS S.LP
  144.                 CASE 'L': RESULTIS S.LL
  145.                 CASE 'S': RESULTIS S.LS  $)
  146.  
  147.         RESULTIS T("LAB") -> S.LAB,
  148.                  T("LLG") -> S.LLG,
  149.                  T("LLL") -> S.LLL,
  150.                  T("LLP") -> S.LLP,
  151.                  T("LOGAND") -> S.LOGAND,
  152.                  T("LOGOR") -> S.LOGOR,
  153.                  T("LSHIFT") -> S.LSHIFT,
  154.                  T("LSTR") -> S.LSTR, ERROR
  155.  
  156.         CASE 'M':
  157.         RESULTIS T("MINUS") -> S.MINUS,
  158.                  T("MULT") -> S.MULT, ERROR
  159.  
  160.         CASE 'N':
  161.         RESULTIS  T("NE") -> S.NE,
  162.                   T("NEG") -> S.NEG,
  163.                   T("NEQV") -> S.NEQV,
  164.                   T("NOT") -> S.NOT,  ERROR
  165.  
  166.         CASE 'P':
  167.         RESULTIS T("PLUS") -> S.PLUS, ERROR
  168.  
  169.         CASE 'Q':
  170.         RESULTIS T("QUERY") -> S.QUERY, ERROR
  171.  
  172.         CASE 'R':
  173.         RESULTIS T("RES") -> S.RES,
  174.                  T("REM") -> S.REM,
  175.                  T("RTAP") -> S.RTAP,
  176.                  T("RTRN") -> S.RTRN,
  177.                  T("RSHIFT") -> S.RSHIFT,
  178.                  T("RSTACK") -> S.RSTACK,
  179.                  T("RV") -> S.RV, ERROR
  180.  
  181.         CASE 'S':
  182.         RESULTIS T("SG") -> S.SG,
  183.                  T("SP") -> S.SP,
  184.                  T("SL") -> S.SL,
  185.                  T("STIND") -> S.STIND,
  186.                  T("STACK") -> S.STACK,
  187.                  T("SAVE") -> S.SAVE,
  188.                  T("SWITCHON") -> S.SWITCHON,
  189.                  T("STORE") -> S.STORE, ERROR
  190.  
  191.         CASE 'T':
  192.         RESULTIS T("TRUE") -> S.TRUE, ERROR              $)1
  193.  
  194.  
  195. AND RDN() = VALOF
  196.     $(1 LET A, NEG = 0, FALSE
  197.  
  198.         CH := RDCH() REPEATWHILE CH='*N' \/ CH='*S'
  199.         IF CH='-' DO $( NEG := TRUE; CH := RDCH()  $)
  200.  
  201.         WHILE '0' LE CH LE '9' DO
  202.                   $( A := A*10 +CH - '0'
  203.                      CH := RDCH()  $)
  204.  
  205.         RESULTIS NEG -> -A, A  $)1
  206.  
  207.  
  208. AND RDL() = VALOF
  209.     $(1 LET A = 0
  210.  
  211.         CH := RDCH() REPEATWHILE CH='*N' \/ CH='*S'
  212.  
  213.         IF CH='L' DO CH := RDCH()
  214.  
  215.         WHILE '0' LE CH LE '9' DO
  216.                   $( A := A*10 + CH - '0'
  217.                      CH := RDCH()  $)
  218.  
  219.         RESULTIS A   $)1
  220.  
  221.  
  222. .
  223.  
  224. //    CG2
  225.  
  226.  
  227. GET "CGHDR"
  228.  
  229. LET START(PARM) BE
  230.     $(1 LET V = VEC 4000
  231.         DATAV, DATAT := V, 4000
  232.      $( LET V = VEC 50
  233.         WORDV := V
  234.  
  235.         SYSIN := FINDINPUT("SYSIN")
  236.         SYSPRINT := FINDOUTPUT("SYSPRINT")
  237.         INTCODE := FINDOUTPUT("INTCODE")
  238.         IF INTCODE=0 DO INTCODE := SYSPRINT
  239.  
  240.         PROGLENGTH := 0
  241.  
  242.         SELECTINPUT(SYSIN)
  243.         SELECTOUTPUT(INTCODE)
  244.  
  245.      $( SSP, STATE := 2, NIL
  246.         DATAP, LINEP,  PARAM := 0, 0, 500
  247.         GENCODE() $) REPEATWHILE OP=S.GLOBAL
  248.  
  249.         SELECTOUTPUT(SYSPRINT)
  250.         WRITEF("*NPROGRAM LENGTH = %N*N", PROGLENGTH)
  251.         FINISH            $)1
  252.  
  253. .
  254.  
  255. //    CG3
  256.  
  257.  
  258. GET "CGHDR"
  259.  
  260. LET GENCODE() BE
  261.     $(1
  262.  
  263. NEXT: OP := READOP()
  264.  
  265.       SWITCHON OP INTO
  266.  
  267.    $( DEFAULT:    SELECTOUTPUT(SYSPRINT)
  268.                   WRITEF("*NUNKNOWN KEY WORD:  %S*N", WORDV)
  269.                   SELECTOUTPUT(INTCODE)
  270.                   GOTO NEXT
  271.  
  272.       CASE S.END: RETURN
  273.  
  274.       CASE S.DEBUG:
  275.            SELECTOUTPUT(SYSPRINT)
  276.            WRITEF("*NSTATE=%N, SSP=%N, AD.A=%N, AD.K=%N*N",
  277.                      STATE,    SSP,    AD.A,    AD.K)
  278.            SELECTOUTPUT(INTCODE)
  279.            GOTO NEXT
  280.  
  281.       CASE S.LP: LOAD(RDN(), M.IP); GOTO NEXT
  282.       CASE S.LG: LOAD(RDN(), M.IG); GOTO NEXT
  283.       CASE S.LL: LOAD(RDL(), M.IL); GOTO NEXT
  284.       CASE S.LN: LOAD(RDN(), M.N); GOTO NEXT
  285.  
  286.       CASE S.LSTR: CGSTRING(RDN()); GOTO NEXT
  287.  
  288.       CASE S.TRUE:  LOAD(-1, M.N); GOTO NEXT
  289.       CASE S.FALSE: LOAD(0, M.N); GOTO NEXT
  290.  
  291.  
  292.       CASE S.LLP: LOAD(RDN(), M.P); GOTO NEXT
  293.       CASE S.LLG: LOAD(RDN(), M.G); GOTO NEXT
  294.       CASE S.LLL: LOAD(RDL(), M.L); GOTO NEXT
  295.  
  296.       CASE S.SP: STOREIN(RDN(), M.P); GOTO NEXT
  297.       CASE S.SG: STOREIN(RDN(), M.G); GOTO NEXT
  298.       CASE S.SL: STOREIN(RDL(), M.L); GOTO NEXT
  299.  
  300.       CASE S.STIND: FORCE.ACAD()
  301.                     CODE(F.S, AD.A, AD.K)
  302.                     SSP, STATE := SSP-2, NIL
  303.                     GOTO NEXT
  304.  
  305.       CASE S.MULT:CASE S.DIV:CASE S.REM:
  306.       CASE S.MINUS:CASE S.EQ:CASE S.NE:
  307.       CASE S.LS:CASE S.GR:CASE S.LE:CASE S.GE:
  308.       CASE S.LSHIFT:CASE S.RSHIFT:
  309.       CASE S.LOGAND:CASE S.LOGOR:CASE S.NEQV:CASE S.EQV:
  310.            FORCE.ACAD()
  311.            CODE(F.L, AD.A, AD.K)
  312.            CODE(F.X, OPCODE(OP), M.N)
  313.            STATE, SSP := AC, SSP-1
  314.            GOTO NEXT
  315.  
  316.       CASE S.RV:CASE S.NEG:CASE S.NOT:
  317.            FORCE.AC()
  318.            CODE(F.X, OPCODE(OP), M.N)
  319.            GOTO NEXT
  320.  
  321.       CASE S.PLUS: FORCE.ACAD()
  322.                    CODE(F.A, AD.A, AD.K)
  323.                    STATE, SSP := AC, SSP-1
  324.                    GOTO NEXT
  325.  
  326.       CASE S.JUMP: FORCE.NIL()
  327.                    CODE(F.J, RDL(), M.L)
  328.                    GOTO NEXT
  329.  
  330.       CASE S.JT:CASE S.JF:
  331.                 FORCE.AC()
  332.                 CODE(OP=S.JT->F.T,F.F, RDL(), M.L)
  333.                 SSP, STATE := SSP-1, NIL
  334.                 GOTO NEXT
  335.  
  336.       CASE S.GOTO: FORCE.AD()
  337.                    CODE(F.J, AD.A, AD.K)
  338.                    SSP, STATE := SSP-1, NIL
  339.                    GOTO NEXT
  340.  
  341.       CASE S.LAB: FORCE.NIL()
  342.                   COMPLAB(RDL())
  343.                   GOTO NEXT
  344.  
  345.       CASE S.QUERY: FORCE.NIL(); SSP := SSP + 1; GOTO NEXT
  346.  
  347.       CASE S.STACK: FORCE.NIL(); SSP := RDN(); GOTO NEXT
  348.  
  349.       CASE S.STORE: FORCE.NIL(); GOTO NEXT
  350.  
  351.       CASE S.ENTRY: $( LET N = RDN()
  352.                        LET L = RDL()
  353.                        WR('*N'); WR('$')
  354.                        FOR I = 1 TO N DO RDN()
  355.                        WR(' ')
  356.                        COMPLAB(L)
  357.                        GOTO NEXT  $)
  358.  
  359.       CASE S.SAVE: SSP := RDN(); GOTO NEXT
  360.  
  361.       CASE S.ENDPROC: RDN(); GOTO NEXT
  362.       CASE S.RTAP:
  363.       CASE S.FNAP: $( LET K = RDN()
  364.                       FORCE.AC()
  365.                       CODE(F.K, K, M.N)
  366.                       TEST OP=S.FNAP
  367.                             THEN SSP, STATE := K+1, AC
  368.                               OR SSP, STATE := K, NIL
  369.                       GOTO NEXT   $)
  370.  
  371.       CASE S.FNRN: FORCE.AC()
  372.                    SSP := SSP - 1
  373.       CASE S.RTRN: CODE(F.X, OPCODE(S.RTRN), M.N)
  374.                    STATE := NIL
  375.                    GOTO NEXT
  376.  
  377.       CASE S.RES: FORCE.AC()
  378.                   CODE(F.J, RDL(), M.L)
  379.                   SSP, STATE := SSP-1, NIL
  380.                   GOTO NEXT
  381.  
  382.       CASE S.RSTACK: FORCE.NIL()
  383.                      SSP, STATE := RDN()+1, AC
  384.                      GOTO NEXT
  385.  
  386.       CASE S.FINISH: CODE(F.X, OPCODE(OP), M.N); GOTO NEXT
  387.  
  388.       CASE S.SWITCHON:
  389.           $( LET N = RDN()
  390.              LET D = RDL()
  391.              FORCE.AC()
  392.              CODE(F.X, OPCODE(OP), M.N)
  393.              CODE(F.D, N, M.N)
  394.              CODE(F.D, D, M.L)
  395.              SSP, STATE := SSP-1, NIL
  396.              FOR I = 1 TO N DO
  397.                   $( CODE(F.D, RDN(), M.N)
  398.                      CODE(F.D, RDL(), M.L)  $)
  399.              GOTO NEXT  $)
  400.  
  401.  
  402.         CASE S.GLOBAL:
  403.              WR('*N')
  404.              FOR I = 0 TO DATAP-2 BY 2 DO WRDATA(DATAV!I, DATAV!(I+1))
  405.              WR('*N')
  406.              FOR I = 1 TO RDN() DO
  407.                  $( WR('G'); WRN(RDN())
  408.                     WR('L'); WRN(RDL()); WR('*S')  $)
  409.              WR('*N'); WR('Z'); WR('*N')
  410.              RETURN
  411.  
  412.       CASE S.DATALAB:
  413.       CASE S.ITEML: DATA(OP, RDL())
  414.                     GOTO NEXT
  415.  
  416.       CASE S.ITEMN: DATA(OP, RDN())
  417.                     GOTO NEXT                   $)1
  418.  
  419. .
  420.  
  421. //    CG4
  422.  
  423.  
  424. GET "CGHDR"
  425.  
  426. LET FORCE.NIL() BE
  427.       SWITCHON STATE INTO
  428.       $( CASE ACAD: CODE(F.S, SSP-2, M.P)
  429.  
  430.          CASE AD:   CODE(F.L, AD.A, AD.K)
  431.  
  432.          CASE AC:   CODE(F.S, SSP-1, M.P)
  433.                     STATE := NIL
  434.  
  435.          CASE NIL:  $)
  436.  
  437. AND FORCE.AD() BE
  438.       SWITCHON STATE INTO
  439.       $( CASE ACAD: CODE(F.S, SSP-2, M.P)
  440.                     GOTO L
  441.  
  442.          CASE AC:   CODE(F.S, SSP-1, M.P)
  443.  
  444.          CASE NIL: AD.A, AD.K := SSP-1, M.IP
  445.          L:        STATE := AD
  446.  
  447.          CASE AD:    $)
  448.  
  449. AND FORCE.AC() BE
  450.       SWITCHON STATE INTO
  451.       $( CASE NIL:  CODE(F.L, SSP-1, M.IP)
  452.                     GOTO L
  453.  
  454.          CASE ACAD: CODE(F.S, SSP-2, M.P)
  455.  
  456.          CASE AD:   CODE(F.L, AD.A, AD.K)
  457.          L:         STATE := AC
  458.  
  459.          CASE AC:   $)
  460.  
  461. AND FORCE.ACAD() BE
  462.       SWITCHON STATE INTO
  463.       $( CASE AD:   CODE(F.L, SSP-2, M.IP)
  464.                     GOTO L
  465.  
  466.          CASE AC:   CODE(F.S, SSP-1, M.P)
  467.  
  468.          CASE NIL:  CODE(F.L, SSP-2, M.IP)
  469.                     AD.A, AD.K := SSP-1, M.IP
  470.          L:         STATE := ACAD
  471.  
  472.          CASE ACAD:  $)
  473.  
  474. AND LOAD(A, K) BE
  475.       SWITCHON STATE INTO
  476.       $( CASE NIL: STATE := AD
  477.                    GOTO M
  478.  
  479.          CASE ACAD:
  480.          CASE AD:  FORCE.AC()
  481.          CASE AC:  STATE := ACAD
  482.          M:        AD.A, AD.K := A, K
  483.                    SSP := SSP + 1  $)
  484.  
  485.  
  486. AND STOREIN(A, K) BE
  487.     $( FORCE.AC()
  488.        CODE(F.S, A, K)
  489.        SSP, STATE := SSP-1, NIL  $)
  490.  
  491. AND CGSTRING(N) BE
  492.     $(1 LET L = NEXTPARAM()
  493.         DATA(S.DATALAB, L)
  494.         DATA(S.CHAR, N)
  495.         FOR I = 1 TO N DO DATA(S.CHAR, RDN())
  496.         LOAD(L, M.L)
  497.         RETURN  $)1
  498.  
  499. AND DATA(K, V) BE
  500.     $( LET P = DATAP
  501.        DATAV!P, DATAV!(P+1) := K, V
  502.        DATAP := DATAP + 2
  503.        IF DATAP>DATAT DO
  504.               $( SELECTOUTPUT(SYSPRINT)
  505.                  WRITES("*NTOO MANY CONSTANTS*N")
  506.                  SELECTOUTPUT(INTCODE)
  507.                  DATAP := 0  $)  $)
  508.  
  509. AND NEXTPARAM() = VALOF $( PARAM := PARAM - 1
  510.                            RESULTIS PARAM  $)
  511.  
  512. .
  513.  
  514. //    CG5
  515.  
  516.  
  517. GET "CGHDR"
  518.  
  519. LET CODE(F, A, K) BE
  520.     $( WR(F)
  521.        SWITCHON K INTO
  522.        $( CASE M.I: WR('I')
  523.           CASE M.N: ENDCASE
  524.  
  525.           CASE M.IG: WR('I')
  526.           CASE M.G:  WR('G')
  527.                      ENDCASE
  528.  
  529.           CASE M.IP: WR('I')
  530.           CASE M.P:  WR('P'); ENDCASE
  531.  
  532.           CASE M.IL: WR('I')
  533.           CASE M.L:  WR('L'); ENDCASE  $)
  534.  
  535.        WRN(A)
  536.        WR(' ')
  537.        PROGLENGTH := PROGLENGTH + 1  $)
  538.  
  539. AND COMPLAB(N) BE $( WRN(N); WR(' ')  $)
  540.  
  541. AND WRDATA(K, N) BE SWITCHON K INTO
  542.       $( CASE S.DATALAB: COMPLAB(N); RETURN
  543.  
  544.          CASE S.ITEMN: CODE(F.D, N, M.N); RETURN
  545.  
  546.          CASE S.ITEML: CODE(F.D, N, M.L); RETURN
  547.  
  548.          CASE S.CHAR:  CODE(F.C, N, M.N); RETURN  $)
  549.  
  550.  
  551. AND OPCODE(OP) = VALOF SWITCHON OP INTO
  552.      $( CASE S.RV: RESULTIS 1
  553.         CASE S.NEG:RESULTIS 2
  554.         CASE S.NOT:RESULTIS 3
  555.         CASE S.RTRN:RESULTIS 4
  556.         CASE S.MULT:  RESULTIS 5
  557.         CASE S.DIV:   RESULTIS 6
  558.         CASE S.REM:   RESULTIS 7
  559.         CASE S.PLUS:  RESULTIS 8
  560.         CASE S.MINUS: RESULTIS 9
  561.         CASE S.EQ:    RESULTIS 10
  562.         CASE S.NE:    RESULTIS 11
  563.         CASE S.LS:    RESULTIS 12
  564.         CASE S.GE:    RESULTIS 13
  565.         CASE S.GR:    RESULTIS 14
  566.         CASE S.LE:    RESULTIS 15
  567.         CASE S.LSHIFT:RESULTIS 16
  568.         CASE S.RSHIFT:RESULTIS 17
  569.         CASE S.LOGAND:RESULTIS 18
  570.         CASE S.LOGOR: RESULTIS 19
  571.         CASE S.NEQV:  RESULTIS 20
  572.         CASE S.EQV:   RESULTIS 21
  573.         CASE S.FINISH:RESULTIS 22
  574.         CASE S.SWITCHON:RESULTIS 23
  575.  
  576.         DEFAULT: SELECTOUTPUT(SYSPRINT)
  577.                  WRITEF("*NUNKNOWN OP %N*N", OP)
  578.                  SELECTOUTPUT(INTCODE)
  579.                  RESULTIS 0  $)
  580.  
  581.  
  582. AND WR(CH) BE
  583.     $( IF CH='*N' DO $( WRCH('*N')
  584.                         LINEP := 0
  585.                         RETURN  $)
  586.  
  587.        IF LINEP=71 DO
  588.               $( WRCH('/')
  589.                  WRCH('*N')
  590.                  LINEP := 0  $)
  591.        LINEP := LINEP + 1
  592.        WRCH(CH)  $)
  593.  
  594. AND WRN(N) BE
  595.     $( IF N<0 DO $( WR('-'); N := -N  $)
  596.        IF N>9 DO WRN(N/10)
  597.        WR(N REM 10 + '0')  $)
  598.  
  599.